CRONO_SDK.h

Go to the documentation of this file.

/*
################################################################################
 
Copyright 2024 Micro-Photon-Devices s.r.l.
 
SOFTWARE PRODUCT: CRONO_SDK 1.0.1
 
Micro-Photon-Devices  (MPD)  expressly disclaims any warranty for the  SOFTWARE
PRODUCT.   The  SOFTWARE  PRODUCT  is provided  'As Is'  without any express or
implied warranty of  any  kind,  including but not limited to any warranties of
merchantability, noninfringement, or fitness of a particular purpose.  MPD does
not  warrant  or  assume responsibility for the accuracy or completeness of any
information, text, graphics, links or other items contained within the SOFTWARE
PRODUCT.  MPD further expressly disclaims  any  warranty  or  representation to
Authorized Users or  to any third party.  In no event shall  MPD  be liable for
any damages (including, without limitation, lost profits, business interruption
or lost information) rising out of  'Authorized Users'  use of or inability  to
use the SOFTWARE PRODUCT,  even if  MPD  has been advised of the possibility of
such damages.  In no event will MPD be liable for loss of data or for indirect,
special, incidental,  consequential  (including lost profit),  or other damages
based in contract, tort or otherwise.  MPD shall have no liability with respect
to the content of the SOFTWARE  PRODUCT or any part thereof,  including but not
limited to  errors  or  omissions contained therein,  libel,  infringements  of
rights of publicity, privacy, trademark rights, business interruption, personal
injury,  loss  of privacy,  moral rights  or  the  disclosure  of  confidential
information.
 
################################################################################
*/
 
#pragma once
 
#ifndef __CRONO_SDK_h__
#define __CRONO_SDK_h__
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include <stdlib.h>
#include <stdint.h>
 
#ifdef _WIN32
#ifdef CRONO_SDK_EXPORTS
#define CRONO_SDK_API __declspec(dllexport)
#else
#define CRONO_SDK_API __declspec(dllimport)
#endif
#else
#define CRONO_SDK_API
#endif
 
#define MAX_PATTERN_LENGTH 8192
#define MIN_GATE_OFF 12
#define MIN_GATE_ON 5
#define MAX_SERIAL_LENGTH 20
#define MAX_DATETIME_LENGTH 100
typedef uint8_t cronoBool; 
typedef struct Crono *CRONO_H; 
typedef enum
{
    NO_ERR = 0,                     
    DEVICE_NOT_FOUND = 1,           
    LOGIC_VERSION_FAIL = 2,         
    DEVICE_NOT_OPEN = 3,            
    DEVICE_ALREADY_OPEN = 4,        
    DEVICE_OPEN_AS_CONVERTER = 5,   
    INVALID_DATA_FILE = 6,          
    SENSOR_FAILED = 7,              
    POWER_FAILED = 8,               
    INVALID_PIXEL_NUMBER = 9,       
    INVALID_DEAD_TIME = 10,         
    INVALID_HALVES_CONFIG = 11,     
    INVALID_START_RATE = 12,        
    INVALID_DIVISION_FACTOR = 13,   
    INVALID_FRAME_BURST_COUNT = 14, 
    INVALID_GATE_LENGHT = 15,       
    INVALID_LASER_SYNC_LENGHT = 16, 
    INVALID_CONFIG = 17,            
    INVALID_THRESHOLD = 18,         
    NO_SUCH_FILE_OR_DIRECTORY = 19, 
    ACQ_ONGOING = 20,               
    ACQ_EXT_TRIG_TIMEOUT = 21,      
    RAM_FULL = 22,                  
    NULL_POINTER = 23,              
    PATTERN_TOO_LONG = 24,          
    INVALID_CHANNEL = 25,           
    INVALID_ENUM = 26,              
    FPGA_FAILED = -1,               
        FPGA_TIMEOUT = -2,                              
} CRONO_Return;
 
typedef enum
{
    CRONO_8X8 = 0,   
    CRONO_128X1 = 1, 
} CRONO_SensorType;
 
typedef struct
{
    CRONO_SensorType SensorType;    
    char Serial[MAX_SERIAL_LENGTH]; 
    int FwMajorVersion;             
    int FwMinorVersion;             
    int FwPatchVersion;             
    int SdkMajorVersion;            
    int SdkMinorVersion;            
    int SdkPatchVersion;            
    int UsbSpeed;                   
} CRONO_DeviceInfo;
 
typedef struct
{
    char DateTime[MAX_DATETIME_LENGTH]; 
        uint64_t acquiredFramesCount;      
} CRONO_AcquisitionInfo;
 
typedef enum
{
    TIMING = 0,  
    COUNTING = 1 
} CRONO_PixelMode;
 
typedef enum
{
    OFF = 0,          
    RISING_EDGE = 1,  
    FALLING_EDGE = 2, 
    BOTH_EDGES = 3    
} CRONO_AuxInputMode;
 
typedef struct
{
    double acquisitionTime;          
    int64_t capturedFrameCount;      
    int64_t decodedFrameCount;       
    int64_t deviceRamUsageBytes;     
    int64_t downloadedBytes;         
    int64_t hostAllocatedBytes;      
    int64_t availableRawCount;       
    int64_t availableFramesCount;    
    int64_t availableTimeTagsCount;  
    int64_t availableHistogramCount; 
    int64_t auxBitACount;            
    int64_t auxBitBCount;            
    cronoBool ongoing;               
    cronoBool deviceRamFull;         
} CRONO_AcquisitionStatus;
 
typedef struct
{
    int deadTimeNs; 
    // sensor roi
    int activePixels;      
    cronoBool half1Enable; 
    cronoBool half2Enable; 
    // counting/timing mode
    CRONO_PixelMode countingMode; 
    // acquisition
    int integPeriodFrames; 
    uint64_t acqMaxFrames;      
    // start
    cronoBool startIsExternal;       
    double frameRate;                
    double externalStartThreshold;   
    cronoBool externalStartPosedge;  
    int externalStartDivisionFactor; 
    // gate
    cronoBool gateIsExternal;                         
    double externalGateThreshold;                     
    cronoBool externalGateInvert;                     
    uint16_t internalGatePattern[MAX_PATTERN_LENGTH]; 
    int internalGatePatternLenght;                    
    // laser sync
    uint16_t laserSyncPattern[MAX_PATTERN_LENGTH]; 
    int laserSyncPatternLenght;                    
    // sma output channels selection
    int chan1Selection; 
    int chan2Selection; 
    int chan3Selection; 
    // ext trigger
    cronoBool acquireOnExtTrigger; 
    int externalTriggerBurstCount; 
    // aux signals sampling modes
    CRONO_AuxInputMode AuxInputASamplingMode; 
    CRONO_AuxInputMode AuxInputBSamplingMode; 
} CRONO_CameraSettings;
 
CRONO_SDK_API CRONO_Return CRONO_Constr(CRONO_H *crono);
 
CRONO_SDK_API CRONO_Return CRONO_Destr(CRONO_H crono);
 
CRONO_SDK_API CRONO_Return CRONO_GetDeviceCount(CRONO_H crono, int *count);
 
CRONO_SDK_API CRONO_Return CRONO_GetDeviceSerial(CRONO_H crono, int deviceIndex, char *buf);
 
CRONO_SDK_API CRONO_Return CRONO_OpenDeviceBySerial(CRONO_H crono, char *serial);
 
CRONO_SDK_API CRONO_Return CRONO_GetDeviceInfo(CRONO_H crono, char *serial, CRONO_DeviceInfo *deviceInfo);
 
CRONO_SDK_API CRONO_Return CRONO_OpenDeviceAsDataConverter(CRONO_H crono, char *rawFilePath);
 
CRONO_SDK_API CRONO_Return CRONO_SetSpadDeadTime(CRONO_H crono, int deadTimeNs);
 
CRONO_SDK_API CRONO_Return CRONO_GetSensorType(CRONO_H crono, CRONO_SensorType *sensorType);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigSensor(CRONO_H crono, int activePixels, cronoBool half1Enable, cronoBool half2Enable, double *maxFrameStartFrequency);
 
CRONO_SDK_API CRONO_Return CRONO_GetActivePixels(CRONO_H crono, int *activePixels);
 
CRONO_SDK_API CRONO_Return CRONO_LoadCameraSettings(CRONO_H crono, CRONO_CameraSettings settings);
 
CRONO_SDK_API CRONO_Return CRONO_GetCameraSettings(CRONO_H crono, CRONO_CameraSettings *settings);
 
CRONO_SDK_API CRONO_Return CRONO_LoadSettingsFromFile(CRONO_H crono, char *path);
 
CRONO_SDK_API CRONO_Return CRONO_SaveSettingsToFile(CRONO_H crono, char *path);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigAcquisition(CRONO_H crono, CRONO_PixelMode pixelMode, cronoBool framesEnable, cronoBool histogramsEnable, cronoBool timeTagsEnable, cronoBool liveEnable, cronoBool unused, const char *rawDataOutPath);
 
CRONO_SDK_API CRONO_Return CRONO_StartAcquisition(CRONO_H crono, uint64_t acqMaxFrames, int integPeriodFrames);
 
CRONO_SDK_API CRONO_Return CRONO_StopAcquisition(CRONO_H crono, cronoBool force);
 
CRONO_SDK_API CRONO_Return CRONO_GetAcquisitionStatus(CRONO_H crono, CRONO_AcquisitionStatus *status);
 
CRONO_SDK_API CRONO_Return CRONO_GetAcquisitionInfo(CRONO_H crono, CRONO_AcquisitionInfo *acqInfo);
 
CRONO_SDK_API CRONO_Return CRONO_GetFramesData(CRONO_H crono, uint32_t *buf, uint64_t capacityNumFrames, uint64_t *copiedNumFrames);
 
CRONO_SDK_API CRONO_Return CRONO_GetTimeTagsData(CRONO_H crono, uint64_t *dataBuf, uint64_t capacity, uint64_t *copiedLen);
 
CRONO_SDK_API CRONO_Return CRONO_GetHistogramData(CRONO_H crono, uint32_t *buf, uint64_t capacityNumHists, uint64_t *copiedNumHists);
 
CRONO_SDK_API CRONO_Return CRONO_GetLiveData(CRONO_H crono, uint32_t *countsBuf, uint32_t *histogramBuf, cronoBool *dataIsNew);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigFrameStartInternal(CRONO_H crono, double frameRate, double *actualBin);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigFrameStartExternal(CRONO_H crono, double frameRate, double threshold, cronoBool externalStartPosedge, int divFactor);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigGateExternal(CRONO_H crono, double threshold, cronoBool externalGateInvert);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigGateInternal(CRONO_H crono, int *pattern, int patternLen);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigLaserSync(CRONO_H crono, int *pattern, int patternLen);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigOutputs(CRONO_H crono, int chan1Selection, int chan2Selection, int chan3Selection);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigAuxiliaryInputs(CRONO_H crono, CRONO_AuxInputMode bitModeA, CRONO_AuxInputMode bitModeB, double bitAThreshold);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigTriggerExternal(CRONO_H crono, int framesBurstCount);
 
CRONO_SDK_API CRONO_Return CRONO_ConfigTriggerInternal(CRONO_H crono);
 
CRONO_SDK_API CRONO_Return CRONO_GetInputFrequencies(CRONO_H crono, double *extStartFrequency, double *extGateFrequency, double *extTriggerFrequency);
 
#ifdef _MPD_DEV_
#include "MPD_Utils.h"
#endif
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif // ifndef __CRONO_SDK_h__